qiqi.util

提供了一些基础的有用的方法。

API

isNumber(value)

检查 value 是否是原始Number数值型或者对象。

参数：

参数	说明	类型	默认值
value	判断的值	any

返回值：如果 value 为一个数值，那么返回 true，否则返回 false。

isPlainObject(value)

检查 value 是否是是普通对象。也就是说该对象由 Object 构造函数创建，或者 [[Prototype]] 为 null 。

参数：

参数	说明	类型	默认值
value	判断的值	any

返回值：如果 value 为一个普通对象，那么返回 true，否则返回 false。

isEmpty(value)

检查 value 是否为一个空对象，集合，映射或者set。判断的依据是除非是有枚举属性的对象，length 大于 0 的 arguments object, array, string 或类jquery选择器。

对象如果被认为为空，那么他们没有自己的可枚举属性的对象。

类数组值，比如arguments对象，array，buffer，string或者类jQuery集合的length 为 0，被认为是空。类似的，map（映射）和set 的size 为 0，被认为是空。

参数：

参数	说明	类型	默认值
value	判断的值	any

返回值：如果 value 为空，那么返回 true，否则返回 false。

forEach(collection, callback)

调用 iteratee 遍历 collection(集合) 中的每个元素， iteratee 调用3个参数： (value, index|key, collection)。如果迭代函数（iteratee）显式的返回 false ，迭代会提前退出。

参数：

参数	说明	类型	默认值
collection	一个用来迭代的集合。	`Array`	`Object`
callback	每次迭代调用的函数。`callback` 函数有三个参数：valueindex	keycollection该函数如果显式的返回 `false` ，迭代会提前退出	`Function`

返回值：无。

includes(ollection, value, [fromIndex=0])

检查 value (值) 是否在 collection (集合) 中。如果 collection (集合)是一个字符串，那么检查 value（值，子字符串）是否在字符串中，否则做等值比较。如果指定 fromIndex 是负数，那么从 collection(集合) 的结尾开始检索。

参数：

参数	说明	类型	默认值
collection	要检索的集合。	`Array`	`Object`
value	要检索的值。	`any`
fromIndex	要检索的索引位置。	`number`	0

返回值：如果找到 value 返回 true，否则返回 false。
示范

globalApi.util.includes([1, 2, 3], 1); // => true
 
globalApi.util.includes([1, 2, 3], 1, 2); // => false
 
globalApi.util.includes({ 'user': 'fred', 'age': 40 }, 'fred'); // => true
 
globalApi.util.includes('pebbles', 'eb'); // => true

sortBy(ollection, [iteratees])

创建一个元素数组。以 iteratee 处理的结果升序排序。这个方法执行稳定排序，也就是说相同元素会保持原始排序。 iteratees 调用1个参数： (value)。

参数：

参数	说明	类型	默认值
collection	用来迭代的集合。	`Array`	`Object`
iteratees	决定如何排序。	`any`
fromIndex	要检索的索引位置。	(...(`Array`	`Array[]`

返回值：返回排序后的数组。
示范

const users = [
  { 'user': 'fred',   'age': 48 },
  { 'user': 'barney', 'age': 36 },
  { 'user': 'fred',   'age': 40 },
  { 'user': 'barney', 'age': 34 }
];
 
globalApi.util.sortBy(users, function(o) { return o.user; });
// => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
 
globalApi.util.sortBy(users, ['user', 'age']);
// => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]
 
globalApi.util.sortBy(users, 'user', function(o) {
  return Math.floor(o.age / 10);
});
// => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]

get(object, path, [defaultValue])

根据 object对象的path路径获取值。如果解析 value 是 undefined 会以 defaultValue 取代。

参数：

参数	说明	类型	默认值
object	要检索的对象。	`Object`
path	要获取属性的路径。	`Array`	`string`
defaultValue	如果解析值是 undefined ，这值会被返回。	`any`

返回值：返回解析的值。
示范

const object = { 'a': [{ 'b': { 'c': 3 } }] };
 
globalApi.util.get(object, 'a[0].b.c');
// => 3
 
globalApi.util.get(object, ['a', '0', 'b', 'c']);
// => 3
 
globalApi.util.get(object, 'a.b.c', 'default');
// => 'default'

set(object, path, value)

设置 object对象中对应 path 属性路径上的值，如果path不存在，则创建。缺少的索引属性会创建为数组，而缺少的属性会创建为对象。

参数：

参数	说明	类型	默认值
object	要修改的对象。	`Object`
path	要设置的对象路径。	`Array`	`string`
value	要设置的值。	`any`

返回值：返回 object。
示范

const object = { 'a': [{ 'b': { 'c': 3 } }] };
 
globalApi.util.set(object, 'a[0].b.c', 4);
console.log(object.a[0].b.c);
// => 4
 
globalApi.util.set(object, ['x', '0', 'y', 'z'], 5);
console.log(object.x[0].y.z);
// => 5

merge(object, ...sources)

递归合并 sources 来源对象自身和继承的可枚举属性到 object 目标对象。如果目标值存在，被解析为undefined的sources 来源对象属性将被跳过。数组和普通对象会递归合并，其他对象和值会被直接分配覆盖。源对象从从左到右分配。后续的来源对象属性会覆盖之前分配的属性。

参数：

参数	说明	类型	默认值
object	目标对象。	`Object`
sources	来源对象。	`...Object`

返回值：返回 object。
示范

const object = {
  'a': [{ 'b': 2 }, { 'd': 4 }]
};
 
const other = {
  'a': [{ 'c': 3 }, { 'e': 5 }]
};
 
globalApi.util.merge(object, other);
// => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }

keys(object)

创建一个 object 的自身可枚举属性名为数组。

参数：

参数	说明	类型	默认值
object	要检索的对象。	`Object`

返回值：返回包含属性名的数组 Array。
示范

function Foo() {
  this.a = 1;
  this.b = 2;
}
 
Foo.prototype.c = 3;
 
globalApi.util.keys(new Foo);
// => ['a', 'b'] (iteration order is not guaranteed)
 
globalApi.util.keys('hi');
// => ['0', '1']

values(object)

创建 object 自身可枚举属性的值为数组。

参数：

参数	说明	类型	默认值
object	要检索的对象。	`Object`

返回值：返回对象属性的值的数组。
示范

function Foo() {
  this.a = 1;
  this.b = 2;
}
 
Foo.prototype.c = 3;
 
globalApi.util.values(new Foo);
// => [1, 2] (无法保证遍历的顺序)
 
globalApi.util.values('hi');
// => ['h', 'i']

ceil(number, [precision])

根据 precision（精度）向上舍入 number。（注： precision（精度）可以理解为保留几位小数。）

参数：

参数	说明	类型	默认值
number	要向上舍入的值。	`Object`
precision	向上舍入的的精度。	`Number`	0

返回值：返回对象属性的值的数组。
示范

function Foo() {
  this.a = 1;
  this.b = 2;
}
 
Foo.prototype.c = 3;
 
globalApi.util.values(new Foo);
// => [1, 2] (无法保证遍历的顺序)
 
globalApi.util.values('hi');
// => ['h', 'i']

floor(number, [precision])

根据 precision（精度）向上舍入 number。（注： precision（精度）可以理解为保留几位小数。）

参数：

参数	说明	类型	默认值
number	要向上舍入的值。	`Object`
precision	向上舍入的的精度。	`Number`	0

返回值：返回对象属性的值的数组。
示范

function Foo() {
  this.a = 1;
  this.b = 2;
}
 
Foo.prototype.c = 3;
 
globalApi.util.values(new Foo);
// => [1, 2] (无法保证遍历的顺序)
 
globalApi.util.values('hi');
// => ['h', 'i']

round(number, [precision])

根据 precision（精度）四舍五入 number。

参数：

参数	说明	类型	默认值
number	要四舍五入的数字。	`Object`
precision	四舍五入的精度。	`Number`	0

返回值：返回对象属性的值的数组。
示范

globalApi.util.round(4.006);
// => 4
 
globalApi.util.round(4.006, 2);
// => 4.01
 
globalApi.util.round(4060, -2);
// => 4100

sum(array)

计算 array 中值的总和

参数：

参数	说明	类型	默认值
array	要迭代的数组。	`Number`

返回值：返回总和。
示范

globalApi.util.sum([4, 2, 8, 6]);
// => 20

isDate(value)

检查 value 是否是 Date 对象。

参数：

参数	说明	类型	默认值
value	要检查的值。	`any`

返回值：如果 value 是一个日期对象，那么返回 true，否则返回 false。
示范

globalApi.util.isDate(new Date); 
// => true

isArray(value)

检查 value 是否是 Date 对象。

参数：

参数	说明	类型	默认值
value	要检查的值。	`any`

返回值：如果 value 是一个数组对象，那么返回 true，否则返回 false。
示范

globalApi.util.isArray([1, 2, 3]);
// => true

globalApi.util.isArray('abc');
// => false

castArray(value)

如果value不是数组, 那么强制转为数组。

参数：

参数	说明	类型	默认值
value	要处理的值。	`any`

返回值：返回转换后的数组。
示范

globalApi.util.castArray(1);
// => [1]
 
globalApi.util.castArray({ 'a': 1 });
// => [{ 'a': 1 }]
 
globalApi.util.castArray();
// => []

every(collection, predicate)

通过 predicate（断言函数）检查 collection（集合）中的所有元素是否都返回真值。一旦 predicate（断言函数）返回假值，迭代就马上停止。predicate（断言函数）调用三个参数： (value, index|key, collection)。

参数：

参数	说明	类型	默认值
collection	一个用来迭代的集合。	`Array`	`Object`
predicate	每次迭代调用的函数。	(`Array`	`Function`

返回值：如果所有元素经 predicate（断言函数）检查后都都返回真值，那么就返回true，否则返回 false 。
示范

globalApi.util.every([true, 1, null, 'yes'], Boolean);
// => false
 
const users = [
  { 'user': 'barney', 'age': 36, 'active': false },
  { 'user': 'fred',   'age': 40, 'active': false }
];
 
globalApi.util.every(users, { 'user': 'barney', 'active': false });
// => false
 
globalApi.util.every(users, ['active', false]);
// => true
 
globalApi.util.every(users, 'active');
// => false

some(collection, predicate)

通过 predicate（断言函数）检查 collection（集合）中的元素是否存在任意 truthy（真值）的元素。一旦 predicate（断言函数）返回 truthy（真值），迭代就马上停止。predicate（断言函数）调用三个参数： (value, index|key, collection)。

参数：

参数	说明	类型	默认值
collection	一个用来迭代的集合。	`Array`	`Object`
predicate	每次迭代调用的函数。	(`Array`	`Function`

返回值：如果任意元素经 predicate 检查都为 truthy（真值），那么就返回true，否则返回 false 。
示范

globalApi.util.some([null, 0, 'yes', false], Boolean);
// => true
 
const users = [
  { 'user': 'barney', 'active': true },
  { 'user': 'fred',   'active': false }
];
 
globalApi.util.some(users, { 'user': 'barney', 'active': false });
// => false
 
globalApi.util.some(users, ['active', false]);
// => true
 
globalApi.util.some(users, 'active');
// => true

filter(collection, predicate)

遍历 collection（集合）元素，返回 predicate（断言函数）返回真值的所有元素的数组。 predicate（断言函数）调用三个参数：(value, index|key, collection)。

参数：

参数	说明	类型	默认值
collection	一个用来迭代的集合。	`Array`	`Object`
predicate	每次迭代调用的函数。	(`Array`	`Function`

返回值：返回一个新的过滤后的数组。
示范

const users = [
  { 'user': 'barney', 'age': 36, 'active': true },
  { 'user': 'fred',   'age': 40, 'active': false }
];
 
globalApi.util.filter(users, function(o) { return !o.active; });
// => objects for ['fred']
 
globalApi.util.filter(users, { 'age': 36, 'active': true });
// => objects for ['barney']
 
globalApi.util.filter(users, ['active', false]);
// => objects for ['fred']
 
globalApi.util.filter(users, 'active');
// => objects for ['barney']

find(collection, predicate, [fromIndex])

遍历 collection（集合）元素，返回 predicate（断言函数）返回真值的第一个元素。 predicate（断言函数）调用三个参数：(value, index|key, collection)。

参数：

参数	说明	类型	默认值
collection	一个用来迭代的集合。	`Array`	`Object`
predicate	每次迭代调用的函数。	(`Array`	`Function`
fromIndex	`开始搜索的索引位置。`	`number`	0

返回值：返回匹配元素，否则返回 undefined。
示范

const users = [
  { 'user': 'barney',  'age': 36, 'active': true },
  { 'user': 'fred',    'age': 40, 'active': false },
  { 'user': 'pebbles', 'age': 1,  'active': true }
];
 
globalApi.util.find(users, function(o) { return o.age < 40; });
// => object for 'barney'
 
globalApi.util.find(users, { 'age': 1, 'active': true });
// => object for 'pebbles'
 
globalApi.util.find(users, ['active', false]);
// => object for 'fred'
 
globalApi.util.find(users, 'active');
// => object for 'barney'

findLast(collection, predicate, [fromIndex])

这个方法类似 find，不同之处在于，findLast是从右至左遍历 collection （集合）元素的。

参数：

参数	说明	类型	默认值
collection	一个用来迭代的集合。	`Array`	`Object`
predicate	每次迭代调用的函数。	(`Array`	`Function`
fromIndex	`开始搜索的索引位置。`	`number`	0

返回值：返回匹配元素，否则返回 undefined。
示范

globalApi.util.findLast([1, 2, 3, 4], function(n) {
  return n % 2 == 1;
});
// => 3

groupBy(collection, iteratee)

创建一个对象，key 是 iteratee 遍历 collection(集合) 中的每个元素返回的结果。分组值的顺序是由他们出现在 collection(集合) 中的顺序确定的。每个键对应的值负责生成 key 的元素组成的数组。iteratee 调用 1 个参数： (value)。

参数：

参数	说明	类型	默认值
collection	一个用来迭代的集合。	`Array`	`Object`
iteratee	这个迭代函数用来转换key。	(`Array`	`Function`

返回值：返回一个组成聚合的对象。
示范

globalApi.util.groupBy([6.1, 4.2, 6.3], Math.floor);
// => { '4': [4.2], '6': [6.1, 6.3] }
 
globalApi.util.groupBy(['one', 'two', 'three'], 'length');
// => { '3': ['one', 'two'], '5': ['three'] }

defaultTo(value, defaultValue)

检查value，以确定一个默认值是否应被返回。如果value为NaN, null, 或者 undefined，那么返回defaultValue默认值。

参数：

参数	说明	类型	默认值
value	要检查的值。	`any`
defaultValue	默认值。	`any`

返回值：返回 resolved 值。
示范

globalApi.util.defaultTo(1, 10);
// => 1
 
globalApi.util.defaultTo(undefined, 10);
// => 10

getCurrentEntitySerialNumber(key)

获取实体的当前的序列号，key是序列的名称，可以是合法的任意标识符，视具体使用场景而定。建议使用实体名称（如：Project），或者实体+字段名（如：ProjectCode）, 如果还不清楚key怎么传，咨询谷宇老师。前端给code赋值时，isManualCode必须赋值为true, 并且 isManualCode必须赋值为true只能在onSave中data中改

参数：

参数	说明	类型	默认值
key	序列的名称。	`string`

返回值：返回 Promise<number> 值。
示范

  const code = await qiqi.util.getCurrentEntitySerialNumber('Product');

getNextEntitySerialNumber(key)

获取的序列值会被占用

参数：

参数	说明	类型	默认值
key	序列的名称。	`string`

返回值：返回 Promise<number> 值。
示范

  const code = await qiqi.util.getNextEntitySerialNumber('Product');

getGeocoder(latitude:number, longitude: number)

根据经纬多获取地理位置

参数：

参数	说明	类型	默认值
latitude	维度	number
longitude	经度	number

返回值：返回 Promise<any> 值。
示范

  const result = await qiqi.util.getGeocoder(39.54, 116.23);

API​

isNumber(value)​

isPlainObject(value)​

isEmpty(value)​

forEach(collection, callback)​

includes(ollection, value, [fromIndex=0])​

sortBy(ollection, [iteratees])​

get(object, path, [defaultValue])​

set(object, path, value)​

merge(object, ...sources)​

keys(object)​

values(object)​

ceil(number, [precision])​

floor(number, [precision])​

round(number, [precision])​

sum(array)​

isDate(value)​

isArray(value)​

castArray(value)​

every(collection, predicate)​

some(collection, predicate)​

filter(collection, predicate)​

find(collection, predicate, [fromIndex])​

findLast(collection, predicate, [fromIndex])​

groupBy(collection, iteratee)​

defaultTo(value, defaultValue)​

getCurrentEntitySerialNumber(key)​

getNextEntitySerialNumber(key)​

getGeocoder(latitude:number, longitude: number)​

API